{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>\n",
    "<img src=\"../../img/ods_stickers.jpg\">\n",
    "## Открытый курс по машинному обучению\n",
    "<center>Автор материала: @oleg."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Вводная"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данном тюториале, я хотел бы рассказать, как использовать в качестве хранилища данных бесплатный SQL сервер. Для предобработки данных будет использован Pandas. В итоге, мы получим удобную базу с данными, на основе которых можно будет строить необходимые модели.  \n",
    "В какой-то момент на работе (консалтинг не связанный никак с IT) коллеги нашли систему, из которой можно выгружать типовые файлы по ценам и производстве электроэнергии по часам. Естественно возникло желание собрать данные за 3 года воедино в удобной форме для дальнейшего анализа и в перспективе прогнозирования временных рядов. Однако, имеется несколько проблем: \n",
    "\n",
    "**1)** Данные выгружаются в виде множества Excel файлов: цены за год - 365/366 файлов, производство электроэнергии по часам и производителям - несколько десятков тысяч файлов.  \n",
    "**2)** Данные требуют предобработки - удаления шапок, лишних столбцов.  \n",
    "**3)** Данные занимают несколько гигабайт и многие инструменты аналитические (в случае моих коллег Power BI), реагируют на них не так хорошо как хотелось бы.  \n",
    "\n",
    "Таким образом, имеем задачу подготовки и хранения данных по времянным рядам. В тюториале я покажу, как это решить начиная с момента, когда ничего нет, до работающей базы и готовых обработчиков. Тюториал будет интересен **для новичков, которые никогда ни с чем подобным не работали**.  \n",
    "Для экономии времени возьмем **первые 7 дней 2015 года**. Данные можно скачать по ссылке:   [Данные для работы](https://drive.google.com/open?id=1UlcTpCWSDMVirX8YU-GOuYKkN2dOdXym)  \n",
    "Содержание данных: 1 файл с ценами (15 Мб) и 159 файлов с производством (7 Мб).  \n",
    "Для начала необходимо установить на машине необходимую инфраструктуру. В данном случае это **SQL Server Express 2017** и **SQL Management Studio**.  \n",
    "У меня на компьютере стоит 64-битная Windows 10 Pro.  \n",
    "Приступим."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Создание сервера"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Скачиваем и устанавливаем SQL Server Express 2017](https://www.microsoft.com/ru-ru/sql-server/sql-server-editions-express). Выбор обусловлен тем, что версия бесплатная с 10 Гб памяти для данных (на работе на сервере установили под Linux, там ограничений нет).  \n",
    "После установки необходимо установить SQL Management Studio для создания, настройки баз, ролей доступов. Для установки, достаточно перейти по ссылке, которую предлагает SQL Server Express после установки:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](../../img/pandas_sql_3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "После этого, создадим базу данных, в которую будем записывать таблицы:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![title](../../img/pandas_sql_6.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Помимо SQL Server Express и SQL Management Studio, может понадобиться скачать и установить драйвер для работы с базой данных.  \n",
    "[ODBC Driver 13 for SQL Server](https://www.microsoft.com/en-us/download/details.aspx?id=53339)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Подключение к серверу и создание SQL-таблиц"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Предварительно подключим необходимые библиотеки. Для работы я буду использовать библиотеки:  \n",
    "[pyodbc](https://github.com/mkleehammer/pyodbc/wiki)  \n",
    "[os](https://docs.python.org/3/library/os.html)  \n",
    "[time](https://docs.python.org/3/library/time.html)  \n",
    "[pandas](http://pandas.pydata.org/pandas-docs/stable/)  \n",
    "[sqlalchemy](http://docs.sqlalchemy.org/en/latest/core/engines.html#sqlalchemy.create_engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "from datetime import datetime\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import pyodbc\n",
    "from sqlalchemy import create_engine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "База данных создана, зачнём работу с данными. Для начала создадим пути к папкам, в которых хранятся данные по ценам и производству электроэнергии в России:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_production = r\"C:\\Users\\Lenovo\\Desktop\\Tutorial\\Production\"\n",
    "path_prices = r\"C:\\Users\\Lenovo\\Desktop\\Tutorial\\Prices\"\n",
    "list_files_production = os.listdir(path_production)\n",
    "list_files_prices = os.listdir(path_prices)\n",
    "\n",
    "files_production = [f for f in list_files_production if f[-3:] == \"xls\"]\n",
    "files_prices = [f for f in list_files_prices if f[-3:] == \"xls\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь создадим SQL таблицы, в которые будем записывать почасовые цены на электроэнергию.\n",
    "Разберёмся по порядку.  \n",
    "Для начала необходимо создать *connection*, через который будет осуществляться связь с базой данных. Для этого мы воспользуемся библиотекой **pyodbc** в которой есть метод *connect*, который позволяет создать подключение. В качестве аргументов необходимо передать следующие данные:  \n",
    "  \n",
    "1) Драйвер (DRIVER) - я использовал *ODBC Driver 13 for SQL Server*  \n",
    "2) Имя сервера (SERVER) - в моем случае это *DESKTOP-1NF3KQV\\SQLEXPRESS* (не забываем экранировать символ *'\\'*)  \n",
    "3) Имя базы данных, в которой будет создана таблица (DATABASE) - мы создали базу ODS_db  \n",
    "4) Данные для аутентификации: логин (UID) и пароль (PWD) если вы настраивали доступ к базе по логину паролю. Т.к. я этого е делал и доступ к базе открыт, вместо указания логина и пароля стоит прописать *Trusted_Connection=Yes*  \n",
    "  \n",
    "**Важно!** После манпуляций с базой не забывайте закрывать соединение с помощью метода *.close()*.  \n",
    "После создания таблицы SQL, необходимо создать *курсор*, помощью которого мы будем отправлять команды к базе SQL, используя созданное соединение. Для этого у соединения есть метод *.cursor()*. Далее в курсор нужно передать строку (запрос SQL), выполнение которой позволит выполнить необходимые манипуляции с таблицей SQL (создание, заполнение и т.п.).  \n",
    "**Важно!** Чтобы измения произошли, обязательно нужно сделать *commit()*.  \n",
    "Попробуем создать таблицу, в которую потом будем записывать цены:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "cnxn = pyodbc.connect(\n",
    "    \"DRIVER= {ODBC Driver 13 for SQL Server}; SERVER=DESKTOP-1NF3KQV\\\\SQLEXPRESS; DATABASE=ODS_db;Trusted_Connection=Yes\"\n",
    ")\n",
    "cursor = cnxn.cursor()\n",
    "\n",
    "if cursor.tables(table=\"Prices\", tableType=\"TABLE\").fetchone():\n",
    "    print(\"Table already exists!\")\n",
    "else:\n",
    "    string = \"CREATE TABLE Prices(ID_node numeric, price float, _datetime datetime)\"\n",
    "    cursor.execute(string)\n",
    "    cnxn.commit()\n",
    "    print(\n",
    "        \"Time (sec) of creating SQL-table for Prices = \", round(time.time() - start, 2)\n",
    "    )\n",
    "\n",
    "cnxn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В качестве строки записывается команда на языке SQL. В данном случае, я создаю 3 столбца для ID узла (минимальная единица, для которой определяется цена), цена и время для которого эта цена актуальна.  \n",
    "  \n",
    "Далее по тому же принципу создадим таблицу с данными по производству электроэнергии. В качестве столбцов взяты: ID узла и время (по данным столбца можно связывать две таблицы), а так же непосредственно объем производства и ID генерирующей единицы, которая произвела данный объем."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "cnxn = pyodbc.connect(\n",
    "    \"DRIVER= {ODBC Driver 13 for SQL Server}; SERVER=DESKTOP-1NF3KQV\\\\SQLEXPRESS; DATABASE=ODS_db;Trusted_Connection=Yes\"\n",
    ")\n",
    "cursor = cnxn.cursor()\n",
    "\n",
    "if cursor.tables(table=\"Production\", tableType=\"TABLE\").fetchone():\n",
    "    print(\"Table already exists!\")\n",
    "else:\n",
    "    string = \"CREATE TABLE Production(ID_unit numeric, ID_node numeric, _datetime datetime, production float)\"\n",
    "    cursor.execute(string)\n",
    "    cnxn.commit()\n",
    "    print(\n",
    "        \"Time (sec) of creating SQL-table for Production = \",\n",
    "        round(time.time() - start, 2),\n",
    "    )\n",
    "\n",
    "cnxn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Предобработка данных и запись в таблицы (1-й способ с использованием библиотеки pyodbc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для начала разберемся с ценами. Один файл Excel соответствует одному дню, номер этого дня мы можем извлечь из названия файла. Каждый час в сутках находится на отдельном листе. Напишем функцию, которая будет извлекать данные.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Внутри файлы с ценами выглядят вот так:  \n",
    "![title](../../img/pandas_sql_7.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Функция предобработки файлов с ценами\n",
    "def Prices_preprocessing(path, f):\n",
    "    df_list = []  ## list с DataFrame по каждому часу\n",
    "    for i in range(24):\n",
    "        df = pd.read_excel(path + \"\\\\\" + f, sheet_name=i)  # Считываем файл в DataFrame\n",
    "        df.drop(\n",
    "            [0, 1], inplace=True\n",
    "        )  # Вырезаем первые две строки, не содержащие ничего полезного\n",
    "        df.drop(\n",
    "            df.columns[[1, 2, 3, 5]], axis=1, inplace=True\n",
    "        )  # Удаляем лишние столбцы, оставляем\n",
    "        df.columns = [\n",
    "            \"ID_node\",\n",
    "            \"price\",\n",
    "        ]  # Для красоты переименуем столбцы с ID узлов и ценами\n",
    "        df[\"_datetime\"] = f[:8]  # Вырезаем из названия дату\n",
    "        df[\"_datetime\"] = df[\"_datetime\"].apply(\n",
    "            lambda x: datetime.strptime(x, \"%Y%m%d\").replace(hour=i)\n",
    "        )\n",
    "        df_list.append(df)\n",
    "    df = pd.concat(\n",
    "        df_list, axis=0, ignore_index=True\n",
    "    )  # Соединим данные с разных страниц в один DataFrame\n",
    "    df.fillna(0, inplace=True)  # Заполним \"дырки\" нулями\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Соединение данных в один DataFrame\n",
    "start = time.time()\n",
    "df_prices = []\n",
    "for f in files_prices:\n",
    "    df_prices.append(Prices_preprocessing(path_prices, f))\n",
    "df_prices = pd.concat(df_prices, axis=0, ignore_index=True)\n",
    "\n",
    "time_prices_preprocessing = time.time() - start\n",
    "print(\"Time of Prices preprocessing = \", round(time_prices_preprocessing, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Препроцессинг цен одной недели занял почти 10 минут. Теперь обработаем файлы, содержащие объём производства электроэнергии. Вот так выглядит каждый из файлов.   \n",
    "![title](../../img/pandas_sql_8.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x):\n",
    "    return datetime.strptime(x[0], \"%Y%m%d\").replace(hour=int(x[1]))\n",
    "\n",
    "\n",
    "# Функция предобработки данных по объёму производства\n",
    "def Production_preprocessing(path, f):\n",
    "    df = pd.read_excel(path + \"\\\\\" + f)\n",
    "    df.drop(\n",
    "        df.columns[\n",
    "            [\n",
    "                1,\n",
    "                3,\n",
    "                4,\n",
    "                6,\n",
    "                7,\n",
    "                9,\n",
    "                10,\n",
    "                12,\n",
    "                13,\n",
    "                15,\n",
    "                16,\n",
    "                18,\n",
    "                19,\n",
    "                21,\n",
    "                22,\n",
    "                24,\n",
    "                25,\n",
    "                27,\n",
    "                28,\n",
    "                30,\n",
    "                31,\n",
    "                33,\n",
    "                34,\n",
    "                36,\n",
    "                37,\n",
    "                39,\n",
    "                40,\n",
    "                42,\n",
    "                43,\n",
    "                45,\n",
    "                46,\n",
    "                48,\n",
    "                49,\n",
    "                51,\n",
    "                52,\n",
    "                54,\n",
    "                55,\n",
    "                57,\n",
    "                58,\n",
    "                60,\n",
    "                61,\n",
    "                63,\n",
    "                64,\n",
    "                66,\n",
    "                67,\n",
    "                69,\n",
    "                70,\n",
    "                72,\n",
    "                73,\n",
    "                75,\n",
    "                76,\n",
    "                77,\n",
    "                78,\n",
    "            ]\n",
    "        ],\n",
    "        axis=1,\n",
    "        inplace=True,\n",
    "    )  # Вырезаем ненужные столбцы\n",
    "    df.drop([0, 1, 2, 3, 4, 5], inplace=True)  # Отрезаем верхние лишние строки\n",
    "    df.drop(df.tail(1).index, inplace=True)  # Отрезаем строку \"Итого\"\n",
    "    df.columns = [\"ID_unit\", \"ID_node\"] + [\n",
    "        x for x in range(24)\n",
    "    ]  # Переименуем столбцы, в том числе данным по производству дадим номер соответствующего часа\n",
    "    df[\"_datetime\"] = f[:8]  # Вырезаем из названия дату\n",
    "    df = pd.melt(\n",
    "        df,\n",
    "        id_vars=[\"ID_unit\", \"ID_node\", \"_datetime\"],\n",
    "        value_vars=[x for x in range(24)],\n",
    "    )  # Превратим данные из столбцов по часам в строки (unpivot)\n",
    "    df.rename(columns={\"value\": \"production\", \"variable\": \"hour\"}, inplace=True)\n",
    "    df[\"_datetime\"] = df[[\"_datetime\", \"hour\"]].apply(\n",
    "        func, axis=1\n",
    "    )  # Склеиваем дату и время\n",
    "    df.drop([\"hour\"], axis=1, inplace=True)  # Убираем ненужный уже столбец \"hour\"\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "df_production = []\n",
    "for f in files_production:\n",
    "    df_production.append(Production_preprocessing(path_production, f))\n",
    "df_production = pd.concat(df_production, axis=0, ignore_index=True)\n",
    "\n",
    "time_production_preprocessing = time.time() - start\n",
    "print(\"Time of Production preprocessing = \", round(time_production_preprocessing, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Препроцессинг занял меньше времени, чем в случае цен."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "cnxn = pyodbc.connect(\n",
    "    \"DRIVER= {ODBC Driver 13 for SQL Server}; SERVER=DESKTOP-1NF3KQV\\\\SQLEXPRESS; DATABASE=ODS_db;Trusted_Connection=Yes\"\n",
    ")\n",
    "cursor = cnxn.cursor()\n",
    "cursor.executemany(\"INSERT INTO Prices values (?, ?, ?);\", df_prices.values.tolist())\n",
    "cnxn.commit()\n",
    "time_prices_commit = time.time() - start\n",
    "\n",
    "start = time.time()\n",
    "cursor.executemany(\n",
    "    \"INSERT INTO Production values (?, ?, ?, ?);\", df_production.values.tolist()\n",
    ")\n",
    "cnxn.commit()\n",
    "time_production_commit = time.time() - start\n",
    "\n",
    "cnxn.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Number of rows in DataFrame with Prices: \", len(df_prices))\n",
    "print(\n",
    "    \"Memory usage of DataFrame with Prices: \",\n",
    "    round(np.sum(list(df_prices.memory_usage())) / 1024 / 1024, 1),\n",
    ")\n",
    "print(\"Time of Prices preprocessing: \", round(time_prices_preprocessing, 1))\n",
    "print(\"Time of Prices commit: \", round(time_prices_commit, 1))\n",
    "print(\"Overall time: \", round(time_prices_preprocessing + time_prices_commit, 1))\n",
    "print(\"\\n\")\n",
    "print(\"Number of rows in DataFrame with Production: \", len(df_production))\n",
    "print(\n",
    "    \"Memory usage of DataFrame with Production: \",\n",
    "    round(np.sum(list(df_production.memory_usage())) / 1024 / 1024, 1),\n",
    ")\n",
    "print(\"Time of Production preprocessing: \", round(time_production_preprocessing, 1))\n",
    "print(\"Time of Production commit: \", round(time_production_commit, 1))\n",
    "print(\n",
    "    \"Overall time: \", round(time_production_preprocessing + time_production_commit, 1)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как мы видим, загрузка данных в базу достаточно затратное дело. Мы загрузили данные всего лишь за 1 неделю и это заняло 3 минуты + предобработка. Мне же нужно загрузить данные за 3 года :) Однако, в конечном итоге мы будем иметь под рукой временные рядов по всем ценам и всему производству в стране (которые извлекаться будут гораздо быстрее), которые можно накладывать на другие данные и строить предиктивные модели. С помощью SQL Management Studio можно поработать с загруженными данными: посмотреть или преобразовать их. Посмотрим, что у нас сейчас хранится на сервере (написал небольшой запрос на SQL, который сводит воедино для каждого производителя энергии объём производства и цену, по которой данный производитель продаёт электроэнергию):  \n",
    "![title](../../img/pandas_sql_9.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2-й способ записать данные на сервер (стандартный метов pandas to_sql + sqlalchemy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В качестве альтернативы, можно воспользоваться стандартным методом DataFrame'a .to_sql(). Он немного медленнее (на данных за одну неделю это незначительно, но на данных за 3 года, всё же ощутимо), но удобнее. Например, можно предварительно не создавать таблицу на сервере. Поэтому рекомендую использовать его. Для начала откроем соединение:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "engine = create_engine(\n",
    "    \"mssql+pyodbc://DESKTOP-1NF3KQV\\\\SQLEXPRESS/ODS_db?driver=ODBC Driver 13 for SQL Server\"\n",
    ")\n",
    "engine.connect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь загрузим данные на сервер. Подробнее хочется остановиться на плюсе второго метода в сравнении с первым - это предварительное создание таблиц. У метода есть полезный пареметр **if_exists** который принимает значения *'fail'*, *'replace'* и *'append'*. Что они позволяют сделать, догадаться не сложно. Мы поставим значение *'replace'*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "df_prices.to_sql(\"Prices_2_way\", con=engine, if_exists=\"replace\")\n",
    "time_prices_commit_2_way = time.time() - start\n",
    "\n",
    "start = time.time()\n",
    "df_production.to_sql(\"Production_2_way\", con=engine, if_exists=\"replace\")\n",
    "time_production_commit_2_way = time.time() - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Number of rows in DataFrame with Prices: \", len(df_prices))\n",
    "print(\n",
    "    \"Memory usage of DataFrame with Prices: \",\n",
    "    round(np.sum(list(df_prices.memory_usage())) / 1024 / 1024, 1),\n",
    ")\n",
    "print(\"Time of Prices preprocessing: \", round(time_prices_preprocessing, 1))\n",
    "print(\"Time of Prices commit: \", round(time_prices_commit_2_way, 1))\n",
    "print(\"Overall time: \", round(time_prices_preprocessing + time_prices_commit_2_way, 1))\n",
    "print(\"\\n\")\n",
    "print(\"Number of rows in DataFrame with Production: \", len(df_production))\n",
    "print(\n",
    "    \"Memory usage of DataFrame with Production: \",\n",
    "    round(np.sum(list(df_production.memory_usage())) / 1024 / 1024, 1),\n",
    ")\n",
    "print(\"Time of Production preprocessing: \", round(time_production_preprocessing, 1))\n",
    "print(\"Time of Production commit: \", round(time_production_commit_2_way, 1))\n",
    "print(\n",
    "    \"Overall time: \",\n",
    "    round(time_production_preprocessing + time_production_commit_2_way, 1),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видим, использование стандартного метода to_sql занимает несколько больше времени. Давайте посмотрим на память, которую занимают в обоих случаях. Это можно сделать просто в SQL Management Studio.  \n",
    "![title](../../img/pandas_sql_10.png) ![title](../../img/pandas_sql_11.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видим, второй способ более затратный. Но пользоваться им всё же удобнее. Посмотрим далее, как работать с полученными базами."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Извлечение данных из базы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Помимо того как извлекать данные, нам интересно где лучше производить манипуляции с данными: на стороне SQL или с помощью pandas. Для этого сравним затраты по времени. Для проверки у меня есть подходящий кейс. Для получения данных в формате \"производство-цена\" нужно соединить таблицы Prices и Production."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "cnxn = pyodbc.connect(\n",
    "    \"DRIVER= {ODBC Driver 13 for SQL Server}; SERVER=DESKTOP-1NF3KQV\\\\SQLEXPRESS; DATABASE=ODS_db;Trusted_Connection=Yes\"\n",
    ")\n",
    "data_extracted = pd.read_sql(\n",
    "    \"SELECT t1.ID_unit, t1.ID_node, t1._datetime, t1.production, t2.price FROM Production AS t1 LEFT JOIN Prices AS t2 ON t1.ID_node=t2.ID_node AND t1._datetime=t2._datetime\",\n",
    "    cnxn,\n",
    ")\n",
    "time_join_extract = time.time() - start\n",
    "print(\"Time of join and extract = \", round(time_join_extract, 1))\n",
    "cnxn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь сначала извлечем данные, потом соединим данные:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "cnxn = pyodbc.connect(\n",
    "    \"DRIVER= {ODBC Driver 13 for SQL Server}; SERVER=DESKTOP-1NF3KQV\\\\SQLEXPRESS; DATABASE=ODS_db;Trusted_Connection=Yes\"\n",
    ")\n",
    "production_extracted = pd.read_sql(\"SELECT * FROM Production\", cnxn)\n",
    "prices_extracted = pd.read_sql(\"SELECT * FROM Prices\", cnxn)\n",
    "data_joined = pd.merge(\n",
    "    production_extracted, prices_extracted, how=\"left\", on=[\"ID_node\", \"_datetime\"]\n",
    ")\n",
    "time_extract_join = time.time() - start\n",
    "print(\"Time of extract and join = \", round(time_extract_join, 1))\n",
    "cnxn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как мы видим, манипуляции с данными лучше делать на уровне SQL запроса к базе данных, чем используя pandas. Это достаточно удобно, делать преобразования на уровне SELECT'ов и работать уже с готовыми данными.  \n",
    "Как можно заметить, обе выгрузки я делал с помощью стандартного метода *read_sql()*. Я выбрал его, т.к. на выходе мы получаем сразу DataFrame (в отличие от, например, метода *fetchall()* из **pyodbc**, результаты которого ещё нужно будет переводить в DataFrame), что экономит время."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Выводы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Использование стандартных методов *to_sql()* и *read_sql()* очень удобно и позволяет хранить большие объёмы данных в SQL Server. Однако, стоит учитывать, что загрузка данных на сервер дело очень не быстрое и если у вас гигабайты данных и миллионы строк (как было у меня), работа может затянуться надолго. При этом, когда вы оперируете очень большими (по меркам простенького ноутбука) данными, могут вылетать ошибки из-за нехватки оперативной памяти. В таком случае, лучше разрезать данные на порции (в случае временных рядов недели, месяца, кварталы) и загружать порциями (не забывайте ставить if_exists='replace', чтобы новые данные не затирали предыдущие).  \n",
    "Метод *read_sql()* позволяет использовать сложные SQL-запросы. Советую пользоваться этим, т.к. это ускорит работу с данными.  \n",
    "Первый подход к загрузке данных я описал не просто так. С помощью него удобно создавать, удалять, заполнять базы прямо из Jupyter Notebook'a, если вам не удобно это делать через SQL Management Studio. Этим удобно пользоваться, когда вы делаете манипуляции не связанные с просто импортом данных из DataFrame'a. Просто записываете нужные команды в SQL-строку и управляете вашими таблицами. При этом всё же не забывайте про SQL Management Studio. Это удобно.  \n",
    "Думаю, описал всё, что необходимо, чтобы с нуля создать у себя на компьютере базу для данных, заполнить её и работать в своё удовольствие."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
